import java.util.*;
/**
 * 链表相交节点检测
 * 找到两个单链表相交的起始节点
 * 使用双指针法，通过交换遍历路径的方式找到相交点
 */
public class getIntersectionNode {
    /**
     * 链表节点类
     * 包含节点值和指向下一个节点的引用
     */
    public static class ListNode{
        int val;        // 节点值
        ListNode next;  // 指向下一个节点的引用
        
        // 无参构造函数
        ListNode(){}
        
        // 带值的构造函数
        ListNode(int val){
            this.val = val;
        }
        
        // 带值和下一个节点的构造函数
        ListNode(int val, ListNode next){
            this.val = val;
            this.next = next;
        }
    }

    /**
     * 查找两个链表的相交节点
     * 算法原理：
     * 1. 两个指针分别从两个链表头开始遍历
     * 2. 当一个指针到达链表末尾时，将其指向另一个链表的头部
     * 3. 如果两个链表相交，两个指针最终会在相交点相遇
     * 4. 如果两个链表不相交，两个指针最终都会指向null
     * @param headA 第一个链表的头节点
     * @param headB 第二个链表的头节点
     * @return 相交节点，如果不存在则返回null
     */
    public static ListNode getIntersectionNodeM(ListNode headA, ListNode headB){
        ListNode a = headA;  // 第一个指针
        ListNode b = headB;  // 第二个指针
        
        // 当两个指针不相等时继续遍历
        // 如果两个链表不相交，两个指针都会走完相同长度(两个链表长度)，最终指向null，循环结束
        // 如果连个链表相交，两个指针最终会走相同长度指向交点(一个链表长度加上另一个链表交点前的长度)，循环结束
        while(a != b){
            // 如果a到达链表末尾，将其指向headB
            if(a == null){
                a = headB;
            }else{
                a = a.next;
            }
            // 如果b到达链表末尾，将其指向headA
            if(b == null){
                b = headA;
            }else{
                b = b.next;
            }
        }
        return a;  // 返回相交节点或null
    }

    /**
     * 主函数：处理输入输出
     * 输入格式：
     * 第一行：第一个链表的节点值
     * 第二行：第二个链表的节点值
     * 第三行：第一个链表在相交前的节点数
     * 第四行：第二个链表在相交前的节点数
     */
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        // 读取并构建第一个链表
        String[] s1 = sc.nextLine().split(" ");
        ListNode headA = new ListNode(Integer.parseInt(s1[0]));
        ListNode node = headA;
        for(int i = 1; i < s1.length; i++){
            node.next = new ListNode(Integer.parseInt(s1[i]));
            node = node.next;
        }
        
        // 读取并构建第二个链表
        String[] s2 = sc.nextLine().split(" ");
        ListNode headB = new ListNode(Integer.parseInt(s2[0]));
        node = headB;
        for(int i = 1; i < s2.length; i++){
            node.next = new ListNode(Integer.parseInt(s2[i]));
            node = node.next;
        }
        
        // 读取两个链表在相交前的节点数
        int skipA = sc.nextInt();  // 第一个链表在相交前的节点数
        sc.nextLine();  // 消耗换行符
        int skipB = sc.nextInt();  // 第二个链表在相交前的节点数
        sc.nextLine();  // 消耗换行符
        
        // 在第一个链表中找到相交的起始节点
        // 例如：如果skipA=3，则移动到第4个节点（索引为3）
        ListNode a = headA;
        for(int i = 0; i < skipA; i++){
            a = a.next;
        }
        
        // 在第二个链表中找到要连接位置的前一个节点
        // 例如：如果skipB=2，则移动到第2个节点（索引为1）
        // 这样b.next就是我们要连接的位置
        ListNode b = headB;
        for(int i = 0; i < skipB - 1; i++){
            b = b.next;
        }
        
        // 将第二个链表连接到第一个链表的相交起始位置
        // 例如：如果链表A是1->2->3->4->5，链表B是9->8->7->6
        // 当skipA=3, skipB=2时：
        // a指向4，b指向8，执行b.next = a后：
        // 链表A：1->2->3->4->5
        // 链表B：9->8->4->5
        b.next = a;
        
        // 查找相交节点并输出结果
        ListNode result = getIntersectionNodeM(headA, headB);
        System.out.println(result.val);
        sc.close();
    }
}
